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