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