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