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