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