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