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