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