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