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