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