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