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