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