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