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