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