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