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