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