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