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