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