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