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