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