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