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