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