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