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